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