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