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