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