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