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