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