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