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