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