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