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