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