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