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