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