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