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