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