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