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