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