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