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