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