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