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