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