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