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