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